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