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