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