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