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