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