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