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