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