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