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