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