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