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