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