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