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