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