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