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