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