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