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