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