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