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