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