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