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