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