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